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