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