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