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