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