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