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