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