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