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