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