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