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