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