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