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