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