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