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