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