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