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