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