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