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