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