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