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