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