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