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